import { getToken } from "@/utils/token";
const heartBeatInterval = 10000; // 心跳间隔时间，这里设置为10秒
let heartBeatTimer = null; // 心跳定时器
let heartBeatStarted = false; // 心跳是否已经启动的标志
let socket = null;
let wsurl = null;
let lockReconnect = false;
let timeoutnum = null;
let lastHeartBeatTime = 0; // 上次接收心跳消息的时间戳
const reconnectTimeout = 60000;

let shouldReconnect = true; // 是否允许自动重新连接标志
let action = null;
const startHeartBeat = () => {
  if (heartBeatStarted) {
    return; // 如果心跳已经启动，则不再重复调用
  }
  // console.log('开始心跳');
  heartBeatStarted = true; // 设置心跳已经启动的标志为true
  // console.log(1);
  heartBeatTimer = setInterval(() => {
    // console.log(2, heartBeatInterval);
    const currentTime = Date.now();
    const timeSinceLastHeartbeat = currentTime - lastHeartBeatTime;
    // console.log('心跳时间:' + timeSinceLastHeartbeat);
    // 判断是否超过心跳间隔的两倍，如果是，则认为连接已断开
    if (timeSinceLastHeartbeat > heartBeatInterval * 2) {
      // console.log('连接已断开，正在尝试重新连接...');
      reconnect();
    } else if (socket && socket.readyState === WebSocket.OPEN) {
      // console.log('发送心跳信息');
      socket.send(
        JSON.stringify({
          action: 2,
          params: "ping",
        })
      ); // 发送心跳消息，可以根据需要设置消息格式
    } else {
      reconnect(); // 如果WebSocket连接已断开，则重新连接
    }
  }, heartBeatInterval);
};

const resetHeartBeat = () => {
  // console.log('清除之前心跳，重新开始心跳');
  clearInterval(heartBeatTimer); // 清除之前的心跳定时器
  heartBeatStarted = false; // 重置心跳启动标志为false
  startHeartBeat(); // 重新开始心跳
};

const initWebSocket = (_wsurl, _action = null) => {
  wsurl = _wsurl;
  action = _action;

  let token = getToken("access_token").substring(6).trim();
  // console.log(wsurl, "wsurl");
  // console.log(token, "token");
  // console.log(action, "action");
  socket = new WebSocket(wsurl, [token]);
  socket.onopen = websocketonopen;
  socket.onerror = websocketonerror;
  socket.onmessage = websocketonmessage;
  socket.onclose = websocketclose;
};

const websocketonopen = (event) => {
  // console.log("WebSocket连接已打开。");
  lastHeartBeatTime = Date.now(); // 记录心跳消息的接收时间
  resetHeartBeat(); // WebSocket连接打开后启动心跳。
  if (action) {
    if (socket && socket.readyState === WebSocket.OPEN) {
      setTimeout(() => {
        socket.send(JSON.stringify(action));
      }, 100);
    }
  }
};

const websocketonmessage = (event) => {
  lastHeartBeatTime = Date.now(); // 更新心跳消息的接收时间
  const data = JSON.parse(event.data);
  // 判断是否是心跳消息
  if (data.action === 2) {
    console.log("收到心跳回复:", data);
    resetHeartBeat(); // 收到消息后重新启动心跳
    return; // 不处理心跳回复消息
  } else {
    console.log("普通消息:", data);
    setOnmessageMessage(data);
  }
};

const websocketonerror = (event) => {
  console.error("WebSocket错误：", event);
  // 在需要时处理WebSocket错误。
};

const websocketclose = (event) => {
  console.log("WebSocket连接已关闭：", event);
  // 在需要时处理WebSocket关闭事件。
  // 可以使用`reconnect()`函数启动重新连接。
  clearInterval(heartBeatTimer); // 清除之前的心跳定时器
  reconnect();
};

const setOnmessageMessage = async (data) => {
  // 在收到消息时更新心跳时间
  // lastHeartBeatTime = Date.now();
  // console.log(event,'eventevent');
  // const data = JSON.parse(event);
  // console.log(data, 'msgdata');
  // 根据消息的类型（type字段）来处理不同的服务消息
  // switch (data.reqName) {
  //     case 'rq/deviceDetail':
  //         handleServiceAMessage(data.data);
  //         break;
  //     case data:
  //         // handleServiceBMessage(data.data);
  //         break;
  //         // 添加其他服务类型的处理
  //         // case 'serviceC':
  //         //   handleServiceCMessage(data.data);
  //         //   break;
  //         // ...
  //     default:
  //         // 处理未知类型的消息
  //         break;
  // }
  handleServiceAMessage(data);
};

const handleServiceAMessage = (data) => {
    console.log(data,'handleServiceAMessage');
  // 处理来自ServiceA的消息
  // console.log("Received message from ServiceA:", data);
  // 自定义全局监听事件
  window.dispatchEvent(
    new CustomEvent("WarnOnmessage", {
      detail: {
        data,
      },
    })
  );
};

const handleServiceBMessage = (data) => {
  // 处理来自ServiceB的消息
  // console.log("Received message from ServiceB:", data);
  // 自定义全局监听事件
  window.dispatchEvent(
    new CustomEvent("WarnMsg", {
      detail: {
        data: data,
      },
    })
  );
};

const websocketsend = (data) => {
  if (socket && socket.readyState === WebSocket.OPEN) {
    socket.send(JSON.stringify(data));
    // console.log('发送数据', data);
  }
};

const closeWebSocket = () => {
  if (socket && socket.readyState === WebSocket.OPEN) {
    shouldReconnect = false; // 阻止自动重新连接
    clearInterval(heartBeatTimer); // 清除心跳定时器
    clearTimeout(timeoutnum);
    socket.close();
  }
};

const reconnect = () => {
  if (lockReconnect || !shouldReconnect) return;
  lockReconnect = true;
  // 清除之前的重连定时器
  clearTimeout(timeoutnum);
  // 没连接上会一直重连，设置延迟避免请求过多
  timeoutnum = setTimeout(() => {
    // console.log('initWebSocket', '重新连接');
    initWebSocket(wsurl, action); // 重新连接时传递之前的WebSocket URL和actions
    lockReconnect = false;
  }, reconnectTimeout);
};

export { initWebSocket, websocketsend, closeWebSocket, socket };
